home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / autop.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  13KB  |  633 lines
  1. /* --------------------------------- autop.c -------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* Autopilot related functions.
  8. */
  9.  
  10. #include "plane.h"
  11.  
  12.  
  13. #define IS_CLASSIC(p)    (MODEL_CLASSIC == EEP(p)->opt[0])
  14.  
  15. /*#define    DEBUG_SPEED*/
  16.  
  17. #define    RANDTIME    8000        /* in milliseconds */
  18. #define    MAXPITCH    (D90/3*2)
  19. #define    MAXALT        5000
  20. #define    MINALT        500
  21. #define    MAXRANGE    (5000L*VONE)
  22. #define    MINCLIMB    (500*VONE)
  23.  
  24. #ifndef DEBUG_SPEED
  25. #define    MINSPEED    (100L*VONE)
  26. #define    MAXSPEED    (250L*VONE)
  27. #define    MINSHOOT    (2000L*VONE)
  28. #else
  29. #define    MINSPEED    (300L*VONE)        /* overflow testing */
  30. #define    MAXSPEED    (2000L*VONE)
  31. #define    MINSHOOT    (3000L*VONE)
  32. #endif
  33.  
  34. #define    PATROLSPEED    250
  35. #define    RANDOMSPEED    150
  36.  
  37. #define    MINDIST        (500L*VONE)
  38.  
  39. #define SETFLAPS    50            /* flaps for takeoff */
  40. #define F16FACT        (D90)            /* smaller = faster */
  41. #define CLFACT        (D90/4)            /* smaller = faster */
  42. #define SENSPITCH    (D90/16)        /* smaller = faster */
  43. #define SENSROLL    (D90/4 )        /* smaller = faster */
  44. #if 0
  45. #define LIFTOFF        (2*fmul (EEP(p)->liftoff_speed, 8428))    /* meters/sec */
  46. #else
  47. #define LIFTOFF        (fmul (EEP(p)->liftoff_speed, 8428/2*3))    /* meters/sec */
  48. #endif
  49. #define ABMIN        20            /* when to set afterburner */
  50.  
  51. LOCAL_FUNC void NEAR
  52. SetMeetCorrection (OBJECT *p, OBJECT *target, VECT R)
  53. {
  54.     int    dist, rv, dt, speed;
  55.     LVECT    LL;
  56.  
  57.     if (!target->speed) {
  58.         R[X] = R[Y] = R[Z] = 0;
  59.         return;
  60.     }
  61.  
  62.     LL[X] = p->V[X] - (long)EX->tspeed[X];    /* target rel v */
  63.     LL[Y] = p->V[Y] - (long)EX->tspeed[Y];
  64.     LL[Z] = p->V[Z] - (long)EX->tspeed[Z];
  65.     rv = (int)(lhypot3d (LL)/VONE);            /* my closure v */
  66.     dist = (int)(ldist3d (target->R, p->R)/VONE);    /* target distance */
  67.  
  68.     if (rv <= dist/8)
  69.         dt = FONE;
  70.     else
  71.         dt = muldiv (FONE/8, dist , rv);
  72.     speed = ihypot3d (EX->tspeed); /* don't trust target->speed */
  73.     if (VMAX/8 <= fmul (dt, speed))
  74.         dt = muldiv (FONE, VMAX/8, speed);
  75.     Vmuldiv (R, EX->tspeed, dt, FONE/8);
  76. }
  77.  
  78. extern void FAR
  79. SetKillCorrection (OBJECT *p, OBJECT *target, VECT R, int *tti)
  80. {
  81.     int    dist, rv, dt, g, speed;
  82.     long    ldist;
  83.     VECT    V;
  84.     LVECT    LL;
  85.  
  86.     speed = BulletSpeed (p, V);            /* bullet speed */
  87.  
  88.     Vsub (LL, p->R, target->R);
  89.     ldist = lhypot3d (LL);
  90.  
  91.     if (ldist)
  92.         rv = speed/VONE - (int)((LL[X]*EX->tspeed[X] +
  93.                      LL[Y]*EX->tspeed[Y] +
  94.                      LL[Z]*EX->tspeed[Z])/(ldist*VONE));
  95.     else
  96.         rv = 0;
  97.  
  98.     if (ldist > VMAX)
  99.         dist = VMAX/VONE;
  100.     else
  101.         dist = (int)(ldist/VONE);
  102.  
  103.     if (rv <= dist/32)
  104.         dt = 32*1000;
  105.     else
  106.         dt = muldiv (1000, dist , rv);
  107.  
  108.     *tti = dt;
  109.  
  110.     if (!target->speed && !(st.flags1 & SF_USEG)) {
  111.         R[X] = R[Y] = R[Z] = 0;
  112.         return;
  113.     }
  114.  
  115.     if (dt < 4000) {
  116. /* projected equivalent speed:
  117.  *     V+A*t/2
  118. */
  119.         R[X] = EX->tspeed[X] + muldiv (EX->taccel[X], dt, 1000*2);
  120.         R[Y] = EX->tspeed[Y] + muldiv (EX->taccel[Y], dt, 1000*2);
  121.         R[Z] = EX->tspeed[Z] + muldiv (EX->taccel[Z], dt, 1000*2);
  122.         if (st.flags1 & SF_USEG)
  123.             R[Z] += muldiv (GACC, dt, 2*1000);    /*bullet G!*/
  124. /* projected movement:
  125.  *    V*t
  126. */
  127.         R[X] = muldiv (R[X], dt, 1000);
  128.         R[Y] = muldiv (R[Y], dt, 1000);
  129.         R[Z] = muldiv (R[Z], dt, 1000);
  130.     } else {
  131.         speed = ihypot3d (EX->tspeed); /* don't trust target->speed */
  132.         if (!speed)
  133.             R[X] = R[Y] = R[Z] = 0;
  134.         else if (VMAX/speed <= dt/1000)
  135.             Vmuldiv (R, EX->tspeed, VMAX, speed);
  136.         else
  137.             Vmuldiv (R, EX->tspeed, dt, 1000);
  138.  
  139.         if ((st.flags1 & SF_USEG) && dt < 3000) {
  140.             g = muldiv (GACC, dt, 2000);
  141.             g = muldiv (g, dt, 1000);
  142.             R[Z] += g;
  143.         }
  144.     }
  145. }
  146.  
  147. LOCAL_FUNC void NEAR
  148. set_throttle (OBJECT *p, POINTER *ptr, int speed)
  149. {
  150.     int    throttle, n;
  151.  
  152.     if (speed < 0)
  153.         speed = 0;
  154.     throttle = (int)pid_calc (EX->PIDthrottle, speed - (long)p->speed,
  155.                     st.interval);
  156.     if (throttle > 0) {
  157.         if (ptr->l[8] <= 5)            /* speed-brakes off */
  158.             ptr->l[8] = 0;
  159.         else
  160.             ptr->l[8] -= 5;
  161.         if (ptr->l[3] < 100-2)
  162.             ptr->l[3] += 2;
  163.         else
  164.             ptr->l[3] = 100;
  165.     } else if (throttle < 0) {
  166.         if (throttle <= -20) {
  167.             if (ptr->l[8] < 100-5)        /* speed-brakes on */
  168.                 ptr->l[8] += 5;
  169.             else
  170.                 ptr->l[8] = 100;
  171.             n = 5;
  172.         } else
  173.             n = 2;
  174.         if (ptr->l[3] > n)
  175.             ptr->l[3] -= n;
  176.         else
  177.             ptr->l[3] = 0;
  178.     }
  179. }
  180.  
  181. LOCAL_FUNC void NEAR
  182. go_to (OBJECT *p, long altitude, ANGLE heading, int speed)
  183. {
  184.     POINTER    *ptr;
  185.     ANGLE    pitch, roll, rdiff, pdiff, hdiff;
  186.     int    pset, hset, rset, tset, ddiff, upright, factor, maxpitch;
  187.     long    ldiff;
  188.  
  189.     if (F(ptr = p->pointer))
  190.         return;
  191.  
  192.     EX->misc[10] = speed - p->speed;
  193.  
  194.     if (IS_CLASSIC(p))
  195.         factor = CLFACT;
  196.     else
  197.         factor = F16FACT;
  198.  
  199.     if (ptr->l[6])
  200.         maxpitch = D90/8;
  201.     else {
  202.         maxpitch = p->speed/VONE/2;
  203.         if (maxpitch > LIFTOFF)
  204.             maxpitch = MAXPITCH;
  205.         else
  206.             maxpitch = muldiv (MAXPITCH, maxpitch, LIFTOFF);
  207.     }
  208.     ldiff = altitude - p->R[Z];         /* climb rate */
  209.     if (ldiff > MINCLIMB)
  210.         pitch = maxpitch;
  211.     else if (ldiff < -MINCLIMB)
  212.         pitch = -maxpitch;
  213.     else
  214.         pitch = muldiv ((int)ldiff, maxpitch, MINCLIMB);
  215.  
  216. #define PITCHBAND    D90/4
  217.     pdiff = pitch + EX->aoa*0 - p->a[X];        /* pitch rate */
  218.     EX->misc[12] = pdiff;
  219.     if (pdiff > PITCHBAND)
  220.         pset = 100;
  221.     else if (pdiff < -PITCHBAND)
  222.         pset = -100;
  223.     else {
  224. #if 0
  225.         pset  = muldiv (pdiff, 100, PITCHBAND);
  226. #else
  227.         pset = (int)pid_calc (EX->PIDpitch, (long)pdiff, st.interval);
  228.         pset += ptr->l[1];
  229.         if (pset > 100)
  230.             pset = 100;
  231.         else if (pset < -100)
  232.             pset = -100;
  233. #endif
  234.     }
  235.     hdiff = heading - p->a[Z];
  236.     if (hdiff > factor)            /* turn rate */
  237.         hset = 100;
  238.     else if (hdiff < -factor)
  239.         hset = -100;
  240.     else
  241.         hset  = muldiv (hdiff, 100, factor);
  242.  
  243.     upright = iabs (hdiff) < D90/16 && iabs (pdiff) < D90/16;
  244.  
  245.     tset = ihypot2d (hset, pset);
  246.     if (0 == tset) {
  247.         roll = 0;
  248.         rdiff = -p->a[Y];
  249.     } else {
  250.         if (pset < 0)
  251.             tset = -tset;
  252.         roll = -ASIN (fdiv (hset, tset));
  253.         rdiff = roll - p->a[Y];
  254.         if (!upright && iabs (rdiff) > D90) { /* go the short way */
  255.             tset = -tset;
  256.             rdiff += D180;
  257.             roll += D180;
  258.         }
  259.         if (tset < -100) {        /* avoid redout */
  260.             tset = 0;
  261.             rdiff += D180;
  262.             roll += D180;
  263.         }
  264.     }
  265.     EX->misc[13] = rdiff;
  266.     if (F(EX->flags & (PF_CHASE|PF_AUTO)))
  267.         return;
  268.  
  269.     if (rdiff > factor)            /* set ailerons */
  270.         rset = -100;
  271.     else if (rdiff < -factor)
  272.         rset = 100;
  273.     else
  274.         rset = -muldiv (rdiff, 100, factor);
  275.     ddiff = rset - ptr->l[0];
  276.     if (ddiff > 25)
  277.         ddiff = 25;
  278.     else if (ddiff < -25)
  279.         ddiff = -25;
  280.     ptr->l[0] += ddiff;
  281.  
  282.  
  283.     tset = fmul (pset, p->cosy) - fmul (hset, p->siny);
  284.  
  285.     if (tset > 100)                /* set elevators */
  286.         tset = 100;
  287.     else if (tset < -100)
  288.         tset = -100;
  289.     ddiff = tset - ptr->l[1];
  290.     if (ddiff > 25)
  291.         ddiff = 25;
  292.     else if (ddiff < -25)
  293.         ddiff = -25;
  294.     ptr->l[1] += ddiff;
  295.  
  296.     set_throttle (p, ptr, speed);
  297. }
  298.  
  299. LOCAL_FUNC void NEAR
  300. set_flaps (OBJECT *p)
  301. {
  302.     int    t, k;
  303.     POINTER    *ptr;
  304.  
  305.     if (F(EX->flags & (PF_CHASE|PF_AUTO)))
  306.         return;
  307.  
  308.     if (F(ptr = p->pointer))
  309.         return;
  310.  
  311.     if (ptr->l[6]) {
  312.         k = LIFTOFF;
  313.         t = k*2 - p->speed/VONE;
  314.         if (t > 0) {
  315.             t = SETFLAPS * t / k;
  316.             if (ptr->l[6] > t)
  317.                 --ptr->l[6];
  318.         } else if (ptr->l[6])
  319.             --ptr->l[6];
  320.     }
  321.     if ((EX->equip & EQ_GEAR) && p->R[Z] > 20*VONE)
  322.         ptr->b[5] = 1;
  323.     
  324. }
  325.  
  326. LOCAL_FUNC void NEAR
  327. takeoff (OBJECT *p)
  328. {
  329.     POINTER    *ptr;
  330.  
  331.     if (F(ptr = p->pointer))
  332.         return;
  333.     if (F(EX->flags & (PF_AUTO|PF_CHASE)))
  334.         return;
  335.     if (ptr->l[9] > 10)        /* release brakes */
  336.         ptr->l[9] -= 10;
  337.     else
  338.         ptr->l[9] = 0;
  339.     if (ptr->l[6]  < SETFLAPS)    /* set flaps */
  340.         ++ptr->l[6];
  341.     SPEED(p) = PATROLSPEED;
  342.     HEADING(p) = 0;
  343.     if (p->speed >= LIFTOFF)
  344.         ALTITUDE(p) = 2000;
  345.     else
  346.         ALTITUDE(p) = (IS_CLASSIC(p) ? 0 : 100);
  347.     go_to (p, ALTITUDE(p)*(long)VONE, HEADING(p), SPEED(p)*VONE);
  348. }
  349.  
  350. LOCAL_FUNC void NEAR
  351. chase (OBJECT *p)
  352. {
  353.     POINTER    *ptr;
  354.     ANGLE    rdiff, pdiff, a;
  355.     int    t, speed, pset, rset, kill;
  356.     long    dist;
  357.     OBJECT    *target;
  358.     VECT    R, RR, VV;
  359.  
  360.     if (F(ptr = p->pointer))
  361.         return;
  362.  
  363.     if (T(target = EX->target) && target->id != EX->tid)
  364.         target = 0;
  365.  
  366.     set_flaps (p);
  367.     if (ptr->l[6]) {
  368.         if (F(EX->flags & (PF_AUTO|PF_CHASE)))
  369.             return;
  370.         pdiff = D90/8 - p->a[X];
  371.         rdiff = 0 - p->a[Y];
  372.         a = D90;
  373.         kill = 0;
  374.         speed = PATROLSPEED*VONE;
  375.         dist = 0;
  376.     } else if (!target) {
  377.         if (F(EX->flags & (PF_AUTO|PF_CHASE))) {
  378.             EX->misc[12] = -p->a[X];
  379.             EX->misc[13] = -p->a[Y];
  380.             EX->misc[10] = 0;
  381.             return;
  382.         }
  383.         a = p->a[Z];
  384.         if (p->R[Y] >  MAXRANGE && iabs(a) < D90)
  385.             a = D180;
  386.         else if (p->R[Y] < -MAXRANGE && iabs(a) > D90)
  387.             a = 0;
  388.         if (p->R[X] >  MAXRANGE && a < 0)
  389.             a = D90;
  390.         else if (p->R[X] < -MAXRANGE && a > 0)
  391.             a = -D90;
  392.         go_to (p, 2000L*VONE, a, PATROLSPEED*VONE);
  393.         return;
  394.     } else {
  395.         if ((EX->flags & PF_KILL) || !(EX->flags & (PF_AUTO|PF_CHASE)))
  396.             SetKillCorrection (p, target, R, &t /*dummy*/);
  397.         else
  398.             SetMeetCorrection (p, target, R);
  399.  
  400.         R[X] = (int)((target->R[X] + R[X] - p->R[X])/VONE);
  401.         R[Y] = (int)((target->R[Y] + R[Y] - p->R[Y])/VONE);
  402.         R[Z] = (int)((target->R[Z] + R[Z] - p->R[Z])/VONE);
  403.         VxMmul (RR, R, p->T);
  404.         pdiff = ATAN (RR[Z], iabs(RR[Y]));    /* pitch error */
  405.         t = ihypot2d (RR[Z], RR[X]);
  406.         a = ATAN (t, iabs(RR[Y]));        /* total error */
  407.  
  408.         VxMmul (VV, EX->tspeed, p->T);
  409.         RR[X] += VV[X]/VONE;
  410.         RR[Z] += VV[Z]/VONE;
  411.         rdiff = ATAN (RR[X], iabs(RR[Z]));    /* roll error */
  412.  
  413.         dist = ihypot3d (RR) * (long)VONE;
  414.         if (T(kill = dist > 0)) {
  415.             if (dist > MAXSPEED*3+MINDIST)
  416.                 speed = MAXSPEED;
  417.             else {
  418.                 speed = (int)((dist-MINDIST)/3);
  419.                 if (speed < MINSPEED)
  420.                     speed = MINSPEED;
  421.             }
  422.         } else {
  423.             speed = MINSPEED;
  424.             dist = -dist;
  425.         }
  426.     }
  427.     EX->misc[12] = pdiff;
  428.     EX->misc[13] = rdiff;
  429.     EX->misc[10] = speed - p->speed;
  430.     if (F(EX->flags & (PF_CHASE|PF_AUTO)))
  431.         return;
  432.  
  433.     if (kill && (EX->flags & PF_KILL) && (EX->radar & R_SHOOT))
  434.         ++ptr->b[2];
  435.  
  436. #if 0
  437. DDshow (p, 4, 0, 13);
  438. DDshow (p, 0, "dist", (long)dist/VONE);
  439. DDshow (p, 2, "pdiff", (long)ANG2DEG00(pdiff));
  440. DDshow (p, 2, "rdiff", (long)ANG2DEG00(rdiff));
  441. DDshow (p, 2, "a",     (long)ANG2DEG00(a));
  442. #endif
  443.  
  444. /* Set ailerons
  445. */
  446.  
  447. #define CHAOS_BAND    DEG(3)
  448.     if (a < CHAOS_BAND) {                /* limiting? */
  449.         t = muldiv (D90, a, CHAOS_BAND);
  450.         if (t < DEG(4))
  451.             t = DEG(4);
  452.         if (rdiff > t)
  453.             rdiff = t;
  454.         else if (rdiff < -t)
  455.             rdiff = -t;
  456. #if 0
  457. DDshow (p, 2, "rdiff", (long)ANG2DEG00(rdiff));
  458. #endif
  459.     }
  460. #undef CHAOS_BAND
  461.  
  462.     rset = (int)pid_calc (EX->PIDroll, (long)rdiff, st.interval);
  463. #if 0
  464. DDshow (p, 0, "rset", (long)rset);
  465. #endif
  466.     if (rset > ptr->l[0]+20)
  467.         ptr->l[0] += 20;
  468.     else if (rset < ptr->l[0]-20)
  469.         ptr->l[0] -= 20;
  470.     else
  471.         ptr->l[0] = rset;
  472.  
  473. /* Set elevators
  474. */
  475. #if 1
  476. #define DEG100    DEG(0)
  477. #define DEG000    DEG(60)
  478.     if ((t = iabs (rdiff)) > DEG100) {
  479.         if (t > DEG000)
  480.             pdiff = 0;
  481.         else {
  482.             t = muldiv (D90, DEG000-t, DEG000-DEG100);
  483.             if (pdiff > t)
  484.                 pdiff = t;
  485.             else if (pdiff < -t)
  486.                 pdiff = -t;
  487.         }
  488. #if 0
  489. DDshow (p, 2, "pdiff", (long)ANG2DEG00(pdiff));
  490. #endif
  491.     }
  492. #undef DEG100
  493. #undef DEG000
  494. #endif
  495.     pset = (int)pid_calc (EX->PIDpitch, (long)pdiff, st.interval);
  496. #if 0
  497. DDshow (p, 0, "pset", (long)pset);
  498. #endif
  499.     pset += ptr->l[1];
  500.     if (pset > 100)
  501.         pset = 100;
  502.     else if (pset < -100)
  503.         pset = -100;
  504.     ptr->l[1] = pset;
  505.  
  506.     set_throttle (p, ptr, speed);
  507. }
  508.  
  509. #define XFULL    DEG(2.5)
  510. #define XMAX    DEG(90)
  511. #define XRATIO    8
  512. #define YFULL    DEG(0.75)
  513. #define YMAX    10000
  514. #define YRATIO    8
  515.  
  516. LOCAL_FUNC void NEAR
  517. do_ils (OBJECT *p)
  518. {
  519.     int    t;
  520.  
  521. /* heading error.
  522. */
  523.     t = -EX->misc[15];
  524.     if (t < -XMAX/XRATIO)
  525.         t = -XMAX;
  526.     else if (t > XMAX/XRATIO)
  527.         t = XMAX;
  528.     else
  529.         t *= XRATIO;
  530.     t -= EX->ilsHeading;
  531.     HEADING(p) = t;
  532.  
  533. /* pitch error.
  534. */
  535.     t = fmul (100*EX->ilsRange, SIN(EX->misc[14]));
  536.     if (t < -(YMAX/YRATIO))
  537.         t = -YMAX;
  538.     else if (t > (YMAX/YRATIO))
  539.         t = YMAX;
  540.     else
  541.         t *= YRATIO;
  542.     ALTITUDE(p) = (int)(p->R[Z]/VONE) + t;
  543.     SPEED(p) = 100;
  544.     go_to (p, ALTITUDE(p)*(long)VONE, HEADING(p),
  545.         SPEED(p)*VONE);
  546. }
  547. #undef XFULL
  548. #undef XMAX
  549. #undef XRATIO
  550. #undef YFULL
  551. #undef YMAX
  552. #undef YRATIO
  553.  
  554. LOCAL_FUNC void NEAR
  555. go_wild (OBJECT *p)
  556. {
  557.     POINTER    *ptr;
  558.     ANGLE    a;
  559.     int    t;
  560.  
  561.     if (F(ptr = p->pointer))
  562.         return;
  563.  
  564.     set_flaps (p);
  565.     if (ptr->l[6])
  566.         ;                    /* stay on course */
  567.     else if ((LIFETIME(p) -= st.interval) <= 0) {
  568.         LIFETIME(p) = RANDTIME;            /* every few seconds */
  569. #ifdef DEBUG_SPEED
  570.         SPEED(p) = (Frand()%80 + 20)*20;    /* overflow testing */
  571. #else
  572.         SPEED(p) = RANDOMSPEED;
  573. #endif
  574.         a = HEADING(p) + (Frand()%D90) * 2 - D90;
  575.         if ((p->R[Y] >  MAXRANGE && iabs(a) < D90) ||
  576.             (p->R[Y] < -MAXRANGE && iabs(a) > D90))
  577.             a = D180 - a;
  578.         if ((p->R[X] >  MAXRANGE && a < 0) ||
  579.             (p->R[X] < -MAXRANGE && a > 0))
  580.             a = -a;
  581.         HEADING(p) = a;
  582.  
  583.         t = ALTITUDE(p) + Frand()%4000 - 2000;
  584.         if (t > MAXALT)
  585.             t = 2*MAXALT-t;
  586.         else if (t < MINALT)
  587.             t = 2*MINALT-t;
  588.         ALTITUDE(p) = t;
  589.     }
  590.     go_to (p, ALTITUDE(p)*(long)VONE, HEADING(p), SPEED(p)*VONE);
  591. }
  592.  
  593. extern void FAR
  594. dynamics_auto (OBJECT *p)
  595. {
  596.     EX->misc[12] = 0;
  597.     EX->misc[13] = 0;
  598.     EX->misc[10] = 0;
  599.  
  600.     if (EX->hud2 & HUD_ILS && !ils_get (p))
  601.         do_ils (p);
  602.     else if (!(EX->flags & (PF_AUTO | PF_CHASE)))
  603.         chase (p);        /* for director */
  604.     else if (EX->flags & PF_ONGROUND)
  605.         takeoff (p);
  606.     else if (EX->flags & PF_CHASE)
  607.         chase (p);
  608.     else /* if (EX->flags & PF_AUTO) */
  609.         go_wild (p);
  610. }
  611.  
  612. #undef IS_CLASSIC
  613. #undef RANDTIME
  614. #undef MAXPITCH
  615. #undef MAXALT
  616. #undef MINALT
  617. #undef MAXRANGE
  618. #undef MINCLIMB
  619. #undef MINSPEED
  620. #undef MAXSPEED
  621. #undef MINSHOOT
  622. #undef PATROLSPEED
  623. #undef RANDOMSPEED
  624. #undef MINDIST
  625. #undef SETFLAPS
  626. #undef F16FACT
  627. #undef CLFACT
  628. #undef SENSPITCH
  629. #undef SENSROLL
  630. #undef LIFTOFF
  631. #undef ABMIN
  632. #undef PITCHBAND
  633.